// import { Provide } from '@midwayjs/core';
// import { BaseService } from '@cool-midway/core';
// import { InjectEntityModel } from '@midwayjs/typeorm';
// import { Repository, MoreThan, LessThan, In } from 'typeorm';
// import { AutomationWeatherDataEntity } from '../../entity/weather_data';

// /**
//  * 气象数据服务
//  */
// @Provide()
// export class AutomationWeatherDataService extends BaseService {
//   @InjectEntityModel(AutomationWeatherDataEntity)
//   automationWeatherDataEntity: Repository<AutomationWeatherDataEntity>;

//   /**
//    * 更新气象数据
//    * @param weatherData 
//    */
//   async updateWeatherData(weatherData: any) {
//     const weather = new AutomationWeatherDataEntity();
//     Object.assign(weather, weatherData);
//     weather.collectTime = new Date();

//     return await this.automationWeatherDataEntity.save(weather);
//   }

//   /**
//    * 获取最新气象数据
//    * @param cityCode 
//    */
//   async getLatestWeather(cityCode?: string) {
//     const queryBuilder = this.automationWeatherDataEntity.createQueryBuilder('weather');
    
//     if (cityCode) {
//       queryBuilder.where('weather.cityCode = :cityCode', { cityCode });
//     }
    
//     queryBuilder.orderBy('weather.collectTime', 'DESC');
    
//     if (cityCode) {
//       return await queryBuilder.getOne();
//     } else {
//       // 获取所有城市的最新气象数据
//       const subQuery = this.automationWeatherDataEntity
//         .createQueryBuilder('sub')
//         .select('sub.cityCode')
//         .addSelect('MAX(sub.collectTime)', 'maxCollectTime')
//         .groupBy('sub.cityCode');

//       return await queryBuilder
//         .innerJoin(
//           `(${subQuery.getQuery()})`,
//           'latest',
//           'weather.cityCode = latest.cityCode AND weather.collectTime = latest.maxCollectTime'
//         )
//         .setParameters(subQuery.getParameters())
//         .getMany();
//     }
//   }

//   /**
//    * 获取城市气象历史数据
//    * @param cityCode 
//    * @param limit 
//    */
//   async getCityWeatherHistory(cityCode: string, limit: number = 100) {
//     return await this.automationWeatherDataEntity.find({
//       where: { cityCode },
//       order: { collectTime: 'DESC' },
//       take: limit
//     });
//   }

//   /**
//    * 获取气象数据统计
//    * @param cityCode 
//    */
//   async getStatistics(cityCode?: string) {
//     const queryBuilder = this.automationWeatherDataEntity.createQueryBuilder('weather');
    
//     if (cityCode) {
//       queryBuilder.where('weather.cityCode = :cityCode', { cityCode });
//     }

//     const result = await queryBuilder
//       .select([
//         'COUNT(*) as totalRecords',
//         'AVG(weather.temperature) as avgTemperature',
//         'MIN(weather.temperature) as minTemperature',
//         'MAX(weather.temperature) as maxTemperature',
//         'AVG(weather.humidity) as avgHumidity',
//         'MIN(weather.humidity) as minHumidity',
//         'MAX(weather.humidity) as maxHumidity',
//         'AVG(weather.pm25) as avgPm25',
//         'MAX(weather.pm25) as maxPm25',
//         'AVG(weather.aqi) as avgAqi',
//         'MAX(weather.aqi) as maxAqi'
//       ])
//       .getRawOne();

//     return {
//       totalRecords: parseInt(result.totalRecords),
//       temperature: {
//         avg: parseFloat(result.avgTemperature) || 0,
//         min: parseFloat(result.minTemperature) || 0,
//         max: parseFloat(result.maxTemperature) || 0
//       },
//       humidity: {
//         avg: parseFloat(result.avgHumidity) || 0,
//         min: parseFloat(result.minHumidity) || 0,
//         max: parseFloat(result.maxHumidity) || 0
//       },
//       pm25: {
//         avg: parseFloat(result.avgPm25) || 0,
//         max: parseFloat(result.maxPm25) || 0
//       },
//       aqi: {
//         avg: parseFloat(result.avgAqi) || 0,
//         max: parseFloat(result.maxAqi) || 0
//       }
//     };
//   }

//   /**
//    * 获取温度趋势
//    * @param cityCode 
//    * @param hours 
//    */
//   async getTemperatureTrend(cityCode: string, hours: number = 24) {
//     const startTime = new Date();
//     startTime.setHours(startTime.getHours() - hours);

//     const weatherHistory = await this.automationWeatherDataEntity.find({
//       where: { 
//         cityCode,
//         collectTime: MoreThan(startTime)
//       },
//       order: { collectTime: 'ASC' }
//     });

//     return this.groupByHour(weatherHistory, 'temperature');
//   }

//   /**
//    * 获取湿度趋势
//    * @param cityCode 
//    * @param hours 
//    */
//   async getHumidityTrend(cityCode: string, hours: number = 24) {
//     const startTime = new Date();
//     startTime.setHours(startTime.getHours() - hours);

//     const weatherHistory = await this.automationWeatherDataEntity.find({
//       where: { 
//         cityCode,
//         collectTime: MoreThan(startTime)
//       },
//       order: { collectTime: 'ASC' }
//     });

//     return this.groupByHour(weatherHistory, 'humidity');
//   }

//   /**
//    * 获取空气质量趋势
//    * @param cityCode 
//    * @param hours 
//    */
//   async getAirQualityTrend(cityCode: string, hours: number = 24) {
//     const startTime = new Date();
//     startTime.setHours(startTime.getHours() - hours);

//     const weatherHistory = await this.automationWeatherDataEntity.find({
//       where: { 
//         cityCode,
//         collectTime: MoreThan(startTime)
//       },
//       order: { collectTime: 'ASC' }
//     });

//     return {
//       pm25: this.groupByHour(weatherHistory, 'pm25'),
//       aqi: this.groupByHour(weatherHistory, 'aqi')
//     };
//   }

//   /**
//    * 按小时分组数据
//    * @param data 
//    * @param field 
//    */
//   private groupByHour(data: AutomationWeatherDataEntity[], field: string) {
//     const hourlyData = {};
//     data.forEach(item => {
//       const hour = new Date(item.collectTime).getHours();
//       if (!hourlyData[hour]) {
//         hourlyData[hour] = [];
//       }
//       if (item[field] !== undefined && item[field] !== null) {
//         hourlyData[hour].push(item[field]);
//       }
//     });

//     return Object.keys(hourlyData).map(hour => ({
//       hour: parseInt(hour),
//       count: hourlyData[hour].length,
//       avg: hourlyData[hour].reduce((sum, val) => sum + val, 0) / hourlyData[hour].length,
//       min: Math.min(...hourlyData[hour]),
//       max: Math.max(...hourlyData[hour])
//     }));
//   }

//   /**
//    * 同步气象数据
//    * @param cityCodes 
//    */
//   async syncWeatherData(cityCodes?: string[]) {
//     // 这里可以实现从第三方API获取气象数据的逻辑
//     // 例如：调用天气API，获取实时数据并保存到数据库
    
//     let syncCount = 0;
//     let failedCount = 0;
//     const details = [];

//     const targetCities = cityCodes || await this.getCityCodes();

//     for (const cityCode of targetCities) {
//       try {
//         // 模拟从API获取数据
//         const weatherData = await this.fetchWeatherFromAPI(cityCode);
//         await this.updateWeatherData(weatherData);
//         syncCount++;
//         details.push({ cityCode, status: 'success' });
//       } catch (error) {
//         failedCount++;
//         details.push({ cityCode, status: 'failed', error: error.message });
//       }
//     }

//     return { syncCount, failedCount, details };
//   }

//   /**
//    * 模拟从API获取气象数据
//    * @param cityCode 
//    */
//   private async fetchWeatherFromAPI(cityCode: string) {
//     // 这里应该调用实际的气象API
//     // 现在返回模拟数据
//     return {
//       cityCode,
//       cityName: `城市${cityCode}`,
//       temperature: Math.round(Math.random() * 30 + 5), // 5-35度
//       humidity: Math.round(Math.random() * 60 + 30), // 30-90%
//       weather: ['晴', '多云', '阴', '小雨', '中雨'][Math.floor(Math.random() * 5)],
//       pm25: Math.round(Math.random() * 200 + 10), // 10-210
//       aqi: Math.round(Math.random() * 300 + 50), // 50-350
//       airQuality: ['优', '良', '轻度污染', '中度污染', '重度污染'][Math.floor(Math.random() * 5)],
//       windSpeed: Math.round(Math.random() * 20 + 1), // 1-21 m/s
//       windDirection: ['北', '东北', '东', '东南', '南', '西南', '西', '西北'][Math.floor(Math.random() * 8)],
//       sunrise: '06:30',
//       sunset: '18:30'
//     };
//   }

//   /**
//    * 获取城市代码列表
//    */
//   private async getCityCodes() {
//     const result = await this.automationWeatherDataEntity
//       .createQueryBuilder('weather')
//       .select('DISTINCT weather.cityCode', 'cityCode')
//       .getRawMany();
    
//     return result.map(item => item.cityCode);
//   }

//   /**
//    * 清理历史数据
//    * @param cutoffDate 
//    * @param cityCode 
//    */
//   async cleanupHistory(cutoffDate: Date, cityCode?: string) {
//     const deleteCondition: any = {
//       collectTime: LessThan(cutoffDate)
//     };

//     if (cityCode) {
//       deleteCondition.cityCode = cityCode;
//     }

//     return await this.automationWeatherDataEntity.delete(deleteCondition);
//   }

//   /**
//    * 获取气象预警信息
//    * @param cityCode 
//    */
//   async getWeatherAlerts(cityCode?: string) {
//     // 这里可以实现预警逻辑
//     // 例如：根据预设的阈值检查当前气象数据，生成预警信息
    
//     const latestWeather = await this.getLatestWeather(cityCode);
//     const alerts = [];

//     if (Array.isArray(latestWeather)) {
//       for (const weather of latestWeather) {
//         alerts.push(...this.checkWeatherAlerts(weather));
//       }
//     } else if (latestWeather) {
//       alerts.push(...this.checkWeatherAlerts(latestWeather));
//     }

//     return alerts;
//   }

//   /**
//    * 检查单个城市的气象预警
//    * @param weather 
//    */
//   private checkWeatherAlerts(weather: AutomationWeatherDataEntity) {
//     const alerts = [];

//     // 高温预警
//     if (weather.temperature > 35) {
//       alerts.push({
//         cityCode: weather.cityCode,
//         cityName: weather.cityName,
//         type: 'temperature',
//         level: 'warning',
//         message: `高温预警：当前温度${weather.temperature}°C，超过35°C`
//       });
//     }

//     // 空气质量预警
//     if (weather.aqi > 200) {
//       alerts.push({
//         cityCode: weather.cityCode,
//         cityName: weather.cityName,
//         type: 'aqi',
//         level: 'danger',
//         message: `空气质量预警：当前AQI${weather.aqi}，空气质量${weather.airQuality}`
//       });
//     }

//     // PM2.5预警
//     if (weather.pm25 > 150) {
//       alerts.push({
//         cityCode: weather.cityCode,
//         cityName: weather.cityName,
//         type: 'pm25',
//         level: 'warning',
//         message: `PM2.5预警：当前PM2.5浓度${weather.pm25}μg/m³，超过150μg/m³`
//       });
//     }

//     return alerts;
//   }

//   /**
//    * 设置预警规则
//    * @param cityCode 
//    * @param rules 
//    */
//   async setAlertRules(cityCode: string, rules: any[]) {
//     // 这里可以实现预警规则的保存逻辑
//     // 例如：保存到配置表或缓存中
//     console.log(`Setting alert rules for city ${cityCode}:`, rules);
//     return '预警规则设置成功';
//   }

//   /**
//    * 获取报告数据
//    * @param cityCodes 
//    * @param startTime 
//    * @param endTime 
//    * @param fields 
//    */
//   async getReportData(cityCodes?: string[], startTime?: string, endTime?: string, fields?: string[]) {
//     const queryBuilder = this.automationWeatherDataEntity.createQueryBuilder('weather');

//     if (cityCodes && cityCodes.length > 0) {
//       queryBuilder.andWhere('weather.cityCode IN (:...cityCodes)', { cityCodes });
//     }

//     if (startTime) {
//       queryBuilder.andWhere('weather.collectTime >= :startTime', { startTime });
//     }

//     if (endTime) {
//       queryBuilder.andWhere('weather.collectTime <= :endTime', { endTime });
//     }

//     queryBuilder.orderBy('weather.cityCode', 'ASC')
//                .addOrderBy('weather.collectTime', 'DESC');

//     const data = await queryBuilder.getMany();

//     // 按城市分组
//     const groupedData = {};
//     data.forEach(weather => {
//       if (!groupedData[weather.cityCode]) {
//         groupedData[weather.cityCode] = [];
//       }
//       groupedData[weather.cityCode].push(weather);
//     });

//     return {
//       summary: {
//         totalRecords: data.length,
//         cityCount: Object.keys(groupedData).length,
//         timeRange: { startTime, endTime },
//         fields: fields || ['temperature', 'humidity', 'weather', 'pm25', 'aqi']
//       },
//       cityData: groupedData
//     };
//   }

//   /**
//    * 获取城市列表
//    */
//   async getCities() {
//     const result = await this.automationWeatherDataEntity
//       .createQueryBuilder('weather')
//       .select(['weather.cityCode', 'weather.cityName'])
//       .groupBy('weather.cityCode, weather.cityName')
//       .getRawMany();

//     return result.map(item => ({
//       cityCode: item.weather_cityCode,
//       cityName: item.weather_cityName
//     }));
//   }

//   /**
//    * 气象数据对比
//    * @param cityCodes 
//    * @param startTime 
//    * @param endTime 
//    * @param field 
//    */
//   async compareWeatherData(cityCodes: string[], startTime: string, endTime: string, field: string) {
//     const data = await this.automationWeatherDataEntity.find({
//       where: {
//         cityCode: In(cityCodes),
//         collectTime: MoreThan(new Date(startTime))
//       },
//       order: { collectTime: 'ASC' }
//     });

//     // 按城市分组并计算统计数据
//     const compareResult = {};
//     cityCodes.forEach(cityCode => {
//       const cityData = data.filter(item => item.cityCode === cityCode);
//       const values = cityData.map(item => item[field]).filter(val => val !== undefined && val !== null);
      
//       if (values.length > 0) {
//         compareResult[cityCode] = {
//           cityName: cityData[0]?.cityName || cityCode,
//           count: values.length,
//           avg: values.reduce((sum, val) => sum + val, 0) / values.length,
//           min: Math.min(...values),
//           max: Math.max(...values),
//           trend: this.calculateTrend(cityData, field)
//         };
//       }
//     });

//     return compareResult;
//   }

//   /**
//    * 计算趋势
//    * @param data 
//    * @param field 
//    */
//   private calculateTrend(data: AutomationWeatherDataEntity[], field: string) {
//     if (data.length < 2) return 'stable';
    
//     const values = data.map(item => item[field]).filter(val => val !== undefined && val !== null);
//     if (values.length < 2) return 'stable';
    
//     const firstValue = values[0];
//     const lastValue = values[values.length - 1];
//     const change = ((lastValue - firstValue) / firstValue) * 100;
    
//     if (change > 5) return 'rising';
//     if (change < -5) return 'falling';
//     return 'stable';
//   }
// }